{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple linear regression "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  Linear regression class is implemented with Normal equation and Gradient descent methods and feature scaling is also developed\n",
    "####  Dataset is downloaded from super data science website. Independent column is Years of experience and Dependent column is Salary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinearRegression:\n",
    "    def __init__(self,X,Y): \n",
    "        ones=np.ones(X.shape)\n",
    "        X=np.append(ones,X,axis=1)\n",
    "        self.X=X\n",
    "        self.Y=Y\n",
    "        self.m=X.shape[0]\n",
    "        self.n=X.shape[1]\n",
    "        self.theta=np.random.randn(X.shape[1])\n",
    "        \n",
    "    def computeCostFunction(self):\n",
    "        h=np.matmul(self.X,self.theta)\n",
    "        self.J=(1/(2*self.m))*np.sum((h-self.Y)**2)\n",
    "        return self.J\n",
    "    \n",
    "    def performGradientDescent(self,num_of_iter,alpha):\n",
    "        self.Cost_history=[]\n",
    "        self.theta_history=[]\n",
    "        for x in range(num_of_iter):\n",
    "            h=np.matmul(self.X,self.theta)\n",
    "            J=self.computeCostFunction()\n",
    "            self.Cost_history.append(J)\n",
    "            self.theta_history.append(self.theta)\n",
    "            temp=h-self.Y\n",
    "            self.theta=self.theta-(alpha/self.m)*(self.X.T.dot(temp))\n",
    "        return self.theta,self.Cost_history,self.theta_history\n",
    "            \n",
    "        \n",
    "    def predict(self,X_test,Y_test):\n",
    "        ones=np.ones(X_test.shape)\n",
    "        X_test=np.append(ones,X_test,axis=1)\n",
    "        self.Y_pred=np.matmul(X_test,self.theta)\n",
    "        self.error_percentage=(abs(self.Y_pred-Y_test)/Y_test)*100\n",
    "        return self.Y_pred,self.error_percentage\n",
    "    \n",
    "    def predictUsingNormalEquation(self,X_test,Y_test):\n",
    "        ones=np.ones(X_test.shape)\n",
    "        X_test=np.append(ones,X_test,axis=1)\n",
    "        inv=np.linalg.inv(np.matmul(self.X.T,self.X))\n",
    "        self.w=np.matmul(np.matmul(inv,self.X.T),self.Y)\n",
    "        y_pred=np.matmul(X_test,self.w)\n",
    "        return y_pred,(abs(Y_test-y_pred)/Y_test)*100\n",
    "        \n",
    "        \n",
    "    \n",
    "        \n",
    "    def returnTheta(self):\n",
    "        return self.theta\n",
    "    \n",
    "    def returnX(self):\n",
    "        return self.X\n",
    "        \n",
    "    def returnY(self):\n",
    "        return self.Y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FeatureScaling:\n",
    "    def __init__(self,X,y):\n",
    "        self.X=X.copy()\n",
    "        if y.ndim==1:\n",
    "            y=np.reshape(y,(y.shape[0],1))\n",
    "        self.y=y.copy()\n",
    "        self.minMax_X={}\n",
    "        self.minMax_y={}\n",
    "    \n",
    "    def fit_transform_X(self):\n",
    "        num_of_features=self.X.shape[1]\n",
    "        for i in range(num_of_features):\n",
    "            feature=self.X[:,i]\n",
    "            Mean=np.mean(feature)\n",
    "            Min=np.min(feature)\n",
    "            Max=np.max(feature)\n",
    "            feature=(feature-Mean)/(Max-Min)\n",
    "            self.minMax_X[i]=np.array([Mean,Min,Max])\n",
    "            self.X[:,i]=feature\n",
    "        return self.X.copy()\n",
    "    \n",
    "    def fit_transform_Y(self):\n",
    "        num_of_features=self.y.shape[1]\n",
    "        for i in range(num_of_features):\n",
    "            feature=self.y[:,i]\n",
    "            Mean=np.mean(feature)\n",
    "            Min=np.min(feature)\n",
    "            Max=np.max(feature)\n",
    "            feature=(feature-Mean)/(Max-Min)\n",
    "            self.minMax_y[i]=np.array([Mean,Min,Max])\n",
    "            self.y[:,i]=feature\n",
    "        return np.reshape(self.y,self.y.shape[0])\n",
    "    \n",
    "    def inverse_transform_X(self,X):\n",
    "        X_transformed=X.copy()\n",
    "        num_of_features=X_transformed.shape[1]\n",
    "        for i in range(num_of_features):\n",
    "            feature=X_transformed[:,i]\n",
    "            Mean=self.minMax_X[i][0]\n",
    "            Min=self.minMax_X[i][1]\n",
    "            Max=self.minMax_X[i][2]\n",
    "            feature=feature*(Max-Min)+Mean\n",
    "            X_transformed[:,i]=feature\n",
    "        return X_transformed\n",
    "    \n",
    "    def inverse_transform_Y(self,y):\n",
    "        y_transformed=y.copy()\n",
    "        if y_transformed.ndim==1:\n",
    "            y_transformed=np.reshape(y_transformed,(y_transformed.shape[0],1))\n",
    "        num_of_features=y_transformed.shape[1]\n",
    "        for i in range(num_of_features):\n",
    "            feature=y_transformed[:,i]\n",
    "            Mean=self.minMax_y[i][0]\n",
    "            Min=self.minMax_y[i][1]\n",
    "            Max=self.minMax_y[i][2]\n",
    "            feature=feature*(Max-Min)+Mean\n",
    "            y_transformed[:,i]=feature\n",
    "        return np.reshape(y_transformed,y_transformed.shape[0])\n",
    "    \n",
    "    def transform_X(self,X):\n",
    "        X_transformed=X.copy()\n",
    "        num_of_features=X_transformed.shape[1]\n",
    "        for i in range(num_of_features):\n",
    "            feature=X_transformed[:,i]\n",
    "            Mean=self.minMax_X[i][0]\n",
    "            Min=self.minMax_y[i][1]\n",
    "            Max=self.minMax_y[i][2]\n",
    "            feature=(feature-Mean)/(Max-Min)\n",
    "            X_transformed[:,i]=feature\n",
    "        return X_transformed\n",
    "    \n",
    "    def transform_Y(self,y):\n",
    "        y_transformed=y.copy()\n",
    "        if y_transformed.ndim==1:\n",
    "            y_transformed=np.reshape(y_transformed,(y_transformed.shape[0],1))\n",
    "        num_of_features=y_transformed.shape[1]\n",
    "        for i in range(num_of_features):\n",
    "            feature=y_transformed[:,i]\n",
    "            Mean=self.minMax_y[i][0]\n",
    "            Min=self.minMax_y[i][1]\n",
    "            Max=self.minMax_y[i][2]\n",
    "            feature=(feature-Mean)/(Max-Min)\n",
    "            y_transformed[:,i]=feature\n",
    "        return np.reshape(y_transformed,y_transformed.shape[0])\n",
    "    \n",
    "    def returnX(self):\n",
    "        return self.X\n",
    "    \n",
    "    def returnY(self):\n",
    "        return self.y\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from LinearRegression import LinearRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    YearsExperience    Salary\n",
      "0               1.1   39343.0\n",
      "1               1.3   46205.0\n",
      "2               1.5   37731.0\n",
      "3               2.0   43525.0\n",
      "4               2.2   39891.0\n",
      "5               2.9   56642.0\n",
      "6               3.0   60150.0\n",
      "7               3.2   54445.0\n",
      "8               3.2   64445.0\n",
      "9               3.7   57189.0\n",
      "10              3.9   63218.0\n",
      "11              4.0   55794.0\n",
      "12              4.0   56957.0\n",
      "13              4.1   57081.0\n",
      "14              4.5   61111.0\n",
      "15              4.9   67938.0\n",
      "16              5.1   66029.0\n",
      "17              5.3   83088.0\n",
      "18              5.9   81363.0\n",
      "19              6.0   93940.0\n",
      "20              6.8   91738.0\n",
      "21              7.1   98273.0\n",
      "22              7.9  101302.0\n",
      "23              8.2  113812.0\n",
      "24              8.7  109431.0\n",
      "25              9.0  105582.0\n",
      "26              9.5  116969.0\n",
      "27              9.6  112635.0\n",
      "28             10.3  122391.0\n",
      "29             10.5  121872.0\n"
     ]
    }
   ],
   "source": [
    "Data=pd.read_csv('Salary_Data.csv')\n",
    "print(Data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>YearsExperience</th>\n",
       "      <th>Salary</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>30.000000</td>\n",
       "      <td>30.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>5.313333</td>\n",
       "      <td>76003.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>2.837888</td>\n",
       "      <td>27414.429785</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.100000</td>\n",
       "      <td>37731.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>3.200000</td>\n",
       "      <td>56720.750000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>4.700000</td>\n",
       "      <td>65237.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>7.700000</td>\n",
       "      <td>100544.750000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>10.500000</td>\n",
       "      <td>122391.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       YearsExperience         Salary\n",
       "count        30.000000      30.000000\n",
       "mean          5.313333   76003.000000\n",
       "std           2.837888   27414.429785\n",
       "min           1.100000   37731.000000\n",
       "25%           3.200000   56720.750000\n",
       "50%           4.700000   65237.000000\n",
       "75%           7.700000  100544.750000\n",
       "max          10.500000  122391.000000"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot of dataset\n",
    "plt.scatter(Data.iloc[:,0:1].values,Data.iloc[:,1].values)\n",
    "plt.xlabel('Years of experience')\n",
    "plt.ylabel('Salary')\n",
    "plt.title('Plot of Data set')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set size : 21\n",
      "Testing set size : 9\n"
     ]
    }
   ],
   "source": [
    "#training and testing size\n",
    "train_size=int(0.7*Data.shape[0])\n",
    "test_size=int(0.3*Data.shape[0])\n",
    "print(\"Training set size : \"+ str(train_size))\n",
    "print(\"Testing set size : \"+str(test_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#shuffle the dataset\n",
    "Data=Data.sample(frac=1)\n",
    "X=Data.iloc[:,0:1].values\n",
    "y=Data.iloc[:,1].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from FeatureScaling import FeatureScaling\n",
    "fs=FeatureScaling(X,y)\n",
    "X=fs.fit_transform_X()\n",
    "y=fs.fit_transform_Y()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#training set split\n",
    "X_train=X[0:train_size,:]\n",
    "Y_train=y[0:train_size]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(21, 1)\n",
      "(21,)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)\n",
    "print(Y_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#testing set split\n",
    "X_test=X[train_size:,:]\n",
    "Y_test=y[train_size:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9, 1)\n",
      "(9,)\n"
     ]
    }
   ],
   "source": [
    "print(X_test.shape)\n",
    "print(Y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#scatter plot of training set\n",
    "plt.scatter(X_train,Y_train)\n",
    "plt.xlabel('Years of experience')\n",
    "plt.ylabel('Salary')\n",
    "plt.title('Plot of training set')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#scatter plot of testing set\n",
    "plt.scatter(X_test,Y_test)\n",
    "plt.xlabel('Years of experience')\n",
    "plt.ylabel('Salary')\n",
    "plt.title('Plot of testing set')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr=LinearRegression(X_train,Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.52625538 -0.80083325]\n"
     ]
    }
   ],
   "source": [
    "theta=lr.returnTheta()\n",
    "print(theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-22.7894123  -24.82722046 -33.3398793   -7.74749019 -86.94147\n",
      "  -5.83150423 -43.19770228  -1.15553092 -53.19727654]\n"
     ]
    }
   ],
   "source": [
    "#testing set prediction\n",
    "y_pred_normal,error_percentage=lr.predictUsingNormalEquation(X_test,Y_test)\n",
    "y_pred_normal=fs.inverse_transform_Y(y_pred_normal)\n",
    "print(error_percentage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2111011693603257\n"
     ]
    }
   ],
   "source": [
    "#training set prediction\n",
    "y_pred_train_normal,error_percentage_train_normal=lr.predictUsingNormalEquation(X_train,Y_train)\n",
    "y_pred_train_normal=fs.inverse_transform_Y(y_pred_train_normal)\n",
    "print(lr.computeCostFunction())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#learning parameters\n",
    "n_iter=1000\n",
    "alpha=0.05\n",
    "\n",
    "theta,J_Array,theta_array=lr.performGradientDescent(n_iter,alpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-25.76723669 -21.20467676 -28.85063095 -10.45489795 -89.52200501\n",
      "  -8.68886278 -45.70121635  -5.19918681 -55.79720929]\n"
     ]
    }
   ],
   "source": [
    "y_pred_grad,ErrorPercentage=lr.predict(X_test,Y_test)\n",
    "print(ErrorPercentage)\n",
    "y_pred_grad=fs.inverse_transform_Y(y_pred_grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 21.80688809  -3.55274879 -10.27129067   3.42229284  27.09174878\n",
      "   6.92847896  18.15596607  18.25368054   1.98395779 -13.81008256\n",
      "  59.51758188 -60.76157121   3.73174878  88.69734786   1.2061223\n",
      " -41.20891576   6.37546956 -44.59226135 -64.15445326 -22.98913651\n",
      "  10.52347012]\n"
     ]
    }
   ],
   "source": [
    "#let's see how train set is predicted\n",
    "y_pred_train,error_for_train=lr.predict(X_train,Y_train)\n",
    "y_pred_train=fs.inverse_transform_Y(y_pred_train)\n",
    "print(error_for_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#inverse scaling the features\n",
    "X_train=fs.inverse_transform_X(X_train)\n",
    "Y_train=fs.inverse_transform_Y(Y_train)\n",
    "X_test=fs.inverse_transform_X(X_test)\n",
    "Y_test=fs.inverse_transform_Y(Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAEWCAYAAACwtjr+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xm4HFW59v/vTRJgM25GITtA4CSGUQUjMjgxSIKA5HAc4PhKUJSXI+CMIfpDUDgGiAqHV0GZw6AMIQciKAFBQJApIUCYAkEimYCEDAQIZHp+f9Rq0rt37zE97O6+P9fV1+5atapqVXXvenoNVaWIwMzMrJzWqXYBzMys/jnYmJlZ2TnYmJlZ2TnYmJlZ2TnYmJlZ2TnYmJlZ2TnY1DhJfSS9JWn7UuZtJJJmS/pMen+6pN/1cD3TJX2ypIVbC5LulPSVapejpyQdLGlm3nSvOr7WPQ42FZZO9rnXaknL8qa7fWKIiFURsVFEvFLKvJUi6QFJx1W7HDkRcVZEnNhZPknXSjqzYNkhEfH3shWumyLikIi4rhzrlrSppAsk/UvS2+nvTZI+Vo7tQemOr6SzJV3VSZ7Zef+biyU9KOkESVrb7ZeDpG9Iurfa5eiIg02FpZP9RhGxEfAKcEReWpsTg6S+lS9l7fLxKj9J6wN/A3YGPgdsAuwK3Agc2s4ytfi5HJr+TwcCY4EfA5dUtUS1LCL8qtILmAkcXJB2NnAD8EdgKXAcsC/wMLAYmAdcCPRL+fsCAQxM09em+X9Jyz8E7NjdvGn+ocALwBLg/wEPAse1sy/7AI8DbwKvAWPz5u2fV/4ngE+l9HOBVcC7wFvABUXWOyiV+ZvA3PT6XifHax2yE8NLwALgemCzvGWOA/6V5p0GzAY+k7e+q/LyfiqVfQkwC/gq8C1gBbA8lft/U9789ayfju08YA7wa2DdNO/g9Nn/CJif9unYDr4n76+3sIzABsAfgDfS8X0U2DLNeyD3eQHfAO4Dzk/5/gkckrfOf0v5lwJ3AhfnH4eC8pyY9qmpgzLnvmvfAmYAM1L6b9L+vAk8BuyXt8wGwDXAIuAZYBQws9hx6OgzzvvOHJuWmQ+cluYdnj63Femzm9KVY57S9gVWAzvnfca/Tt+L14CLgPXTvK2BP6djvRC4P289OwC3pHItAP4nb943gOfTMfgLsF3B8fy/6XguAi5M8/Yg+x9alfZpQbXPbUWPabUL0Mgv2g82y4Ej0j9UE/Ax4OPpC7cTWQA4OeUvFkAWAEOBfmQn4mt7kHdrshPPkWne99M/6HHt7MtjwDHp/cbAx9P77chOhMPS/gxP29wizX+gvXWm+bkTxzVkJ6MPp/V9poPj9UOywNiSTgiXA9ek/Hukf8j9gfXIAsJKigQbYMd0DL6Ujt2WwEfyjt2ZBWXNPxn+AvgHsFU6lo8AZ6R5B6dtnpGO7eeBt4FN2jkGHQWbk8hOXE1An/RZblR4bMlOYiuAr6d8pwCz8tb5KFnwX5cswC6l/WAzHrisk+927rt2B7AZKTCRBevN0/xRZEFrvTTvl8C9Kf8OwLO0H2w6+oxz35nfpXl7Ae8BgwuPXwflbxNsUvpc4Jvp/W+A/03l3YQsuJyV5o1N8/ulY/rpvOPydNrXDdPntn+a9wVgOjAk5TsT+HvB8bwV2JSstrWQdP5In++91T6ndfRyM1rv9EBE/CkiVkfEsoh4LCIeiYiVEfFPsqr8pztYfnxETI6IFcB1wEd6kPdw4ImIuDXNO58sSLRnBTBY0hYRsTQiHknpxwITI2JS2p87gCfJgk53/Cwi3omIJ4FxwDF581odL7Jffz+OiDkR8S7ZP+2XJK0DfBG4JSIejIj3yH4dt9cO/3+AOyLixnTsF0TEE10s71fIgtH8iHgd+DnZiTbnXeDsiFgRERPJToYf7OK6860gC4KDIuuTmxwRb7WT96WIuCIiVpEdwwGStpS0E1kQPzMilkfE/cDtHWxzS+DV3ISkoalf401JzxTk/UVELEqfCxFxTUQsjIiVwHlkJ+lBKe+XyI7Jooj4F9nJuj0dfcY5Z0bEuxHxOFlN6cMdrK+r5gKbp+18A/huKu+bwBjg6JRvBdAf2D4d0/tS+r5kx29URLyd/r8fzNunX0TE9HR8zgb2ltSSt/0xEbEkImaSBeaO/rd7FQeb3mlW/oSknSXdLulVSW+Snbi27GD5V/PevwNs1IO8/fPLEdnPp9kdrOdrZO320yU9KulzKX0H4Jh0MlosaTFZk1v/DtZVTP4x+VfB8rMK8m4P/Clve9PIfhVuXWS/3iL7hVjMdmTNND2xbSpnfpnzTxoL0kk/p7PPqT1XAX8FbpQ0R9I5HfSPFH7WpG32B97IBYSk8Jjme4Ns/wBIAa6ZLFisV5C38Lv8I0nPS1pC1hS0IWu+y9vS9nNuT0efca5c3fk/6KoWsu/LNmT7+mReGW7L2/45qfx3S3pJ0qkpfTuy2toq2toB+G3e+haQNdsNyMtTjn2qCAeb3qnwVty/J6t6D4qITYCf0v6v8VKZR96XPI3CaWkvc/o1djTZP9uvgJtTR/Is4MqIaM57bRgRY3OLdrE82+W9357sF+b7my/IOxv4bME2108nn3n565K0EVmzTjGzyPoyiums3PPITh75ZZ7TyTLteZusCTFnm/cLkf1qPjMidgE+Afw7Wa2qO+YBW6TPK2e79jIDdwPDJW3QQZ73i5h7I+kAsubY/wCayZqf3mLNd/lV2n7O7enoM+5ymbpD0j7AB8iaJ18ja74dkrf9TSNiU4CIeDMivhcRA4ERwChJnyb7Tu0gqU+RTcwCji/Yp6a8VoKS71MlOdjUho3JOqjflrQLWXW73G4D9pJ0RPql/B2y/oeiJH1V0pYRsTqVNch+lV0D/Lukz6brfNaXdICkXM3kNbJ+qM6cLqlJ0h7ASLL+pfb8DvhF7noiSVtL+nyadxNwpKR9Ja1H1lTR3j/qtWQn1f+Q1Dc1OeWaYjor9x+Bn6ZltgJOT+vriSeAo1MZ9gaOys2QdKCk3VOzzptkzTfFfjW3KyJeIqsZnCFpXUmfAA7rYJEryX51T5C0W/pcm8j6izqyMVlf1QKyvowzyWo2OTcCP5bUnD67kztYV0efcWdeAwZ2dRhzGub9ebKBGFdFxHOpZnIZcIGkrZQZIOmQtMwRkv4tbWMJ2WeyimwQzhup7Buk7/T+efv0k/Q/TjoOX+jGPg2Q1K+L+SvOwaY2/IDsBLuUrJbT0Ym2JCLiNeDLZKNt3iD7hT+VrG+hmM8Bz0laStb5+eX0q3sm2a/t08lG37xCtj+5794FrGlm+3UHRXqAbATVnWTt1vd0kPfXZB3Td6fy/INskAUR8RRZ4LyRrKbxKq2bJvKPwctkAw9GkTWdPE42wACyE82HJS2SNL7I4j8j65uaBjxFNkBgTAdl7shPyIYZLyY7jn/Im9cfmEAWaJ4ha1L7Yw+2cQzZwIA3yAYu3EA7n3Vqbvs0WWf2X9K2nyfrEzm62DLJn1P5XiQbHPMmWa0q54w0PTOt9+oO1tXuZ9wFN5B12i+U9GgH+f4i6S2y7+xpZJ3+38ib/wOyprJHyQLKncDgNG8IcA9Zze1BshFnD6S+mMOBXchqMq+QDQwgIm5K+3VTai5/imxgTVfcRXZcX5PUldpdxSlrijfrWKr2zwW+EBW8cFHSIODFiOiVF9PVK0k3kw0QOavaZbH64JqNtUvS8NSEsB7ZL+qVZL/irM5I2lvSjpLWSYM7DicbZmtWErV4Va9VzifIhkOvS9ZEMyINF7b60x+4mWywxGyya0meqm6RrJ64Gc3MzMrOzWhmZlZ2bkZLttxyyxg4cGC1i2FmVlOmTJmyICLavSwix8EmGThwIJMnT652MczMaoqkju708D43o5mZWdk52JiZWdk52JiZWdk52JiZWdk52JiZWdk52JiZWdk52JiZWdk52JiZNaprroETTqjIpnxRp5lZo1m8GDbbbM30JZeUfZOu2ZiZNZLzzmsdaF56qSKbdc3GzKwRvPoqbLvtmukf/hDGjq3Y5h1szMzq2C1T5/CRYfsxcP4raxLnzYNttqloORxszMzq1IO/u54R/3XM+9PnfPo4xn3yy4yZtwrmzWHspOnMXbyM/s1NnDpsCCP2bClbWRxszMzqkcT+eZP7/dcVzN1ka1ixijMnPsN7K1ezbMUqAOYsXsboCdMAyhZwPEDAzKyeXHcdSO9PTm7ZhYGjbssCTbJ42Yr3A03OshWrGDtpetmK5ZqNmVk9WL0a+vRplTT89P/l+eX9uryKuYuXlbpU7ytbzUbSFZJel/R0XtpYSc9LekrS/0pqzps3WtIMSdMlDctLH57SZkg6LS99R0mPSHpR0g2S1k3p66XpGWn+wHLto5lZr3Deea0DzciREMGJ//4xmvq1DkBN/fqw2QbFA1D/5qayFbGczWhXAcML0u4Cdo+IDwEvAKMBJO0KHA3slpa5SFIfSX2A3wKHArsCx6S8AOcC50fEYGARcHxKPx5YFBGDgPNTPjOz+rN8edZkNmrUmrR33oGrrgKy/pcxR+1BS3MTAlqamxhz1B6cccRuRYPQqcOGlK2oZWtGi4j7C2sVEXFn3uTDwBfS+yOB6yPiPeBlSTOAvdO8GRHxTwBJ1wNHSnoOOBD4z5RnHHAmcHFa15kpfTzwG0mKiCjZzpmZVdtJJ8FFF62ZPuMMOPPMNtlG7NnSbqd/o4xG+zpwQ3rfQhZ8cmanNIBZBekfB7YAFkfEyiL5W3LLRMRKSUtS/gWFBZB0AnACwPbbb7+Wu2NmVgFLlkBzc+u0lSvb9Nd0pqMgVA5VGY0m6SfASuC6XFKRbNGD9I7W1TYx4pKIGBoRQ7faaquOC21mVm3Dh7cONJdeChHdDjTVUPGajaSRwOHAQXlNW7OB7fKyDQDmpvfF0hcAzZL6ptpNfv7cumZL6gtsCiwsx76YmVXE3LnQUlALWb261RDn3q6iNRtJw4FRwOcj4p28WROBo9NIsh2BwcCjwGPA4DTybF2yQQQTU5D6G2v6fEYCt+ata2R6/wXgHvfXmFnN2mmn1oHm9tuz2kwNBRooY81G0h+BzwBbSpoNnEE2+mw94C5lB+rhiDgxIp6RdCPwLFnz2kkRsSqt52RgEtAHuCIinkmbGAVcL+lsYCpweUq/HLgmDTJYSBagzMx6lVumdnK7mOeeg113bb1QDf9uln/0Z4YOHRqTJ0+udjHMrAHcMnUOoydMa3UVf1O/Pow5ao8s4BTWWh55BPbem95I0pSIGNpZPt+uxsyswsZOml70djF3/u6m1oFm/fWz2kwvDTTd4dvVmJlVWLHbwsw89/DWCS++CIMGVahE5eeajZlZheXfFuYrU//cOtAMHpzVZuoo0ICDjZlZxZ06bAhNfddh5rmH8993rrkLwB13PAYvvFDFkpWPm9HMzCpsxPe+woj77nt/+uWtt+fJO/5R0Sv6K83BxszqSqdDiqvpvfeyTv98Cxaw4xZbsGN1SlQxDjZmVjcKhxRX4gmUXbbhhtkdmXM23hjefLN65akw99mYWd1ob0hxOZ9A2akFC7LhzPmB5t13GyrQgGs2ZlZH2nvSZDmfQNmhwoszDzwQ7r67TbZe3fRXIg42ZlY3+jc3MadIYCnnEyiLmj4ddt65dVo7N87s1U1/JeRmNDOrG6cOG1LxJ1C2IbUONN/9boc3zuyVTX9l4JqNmdWNXE2gKk1S994LBxzQOq0L957sdU1/ZeJgY2Z1pdJPoATa1louvhhOPLFLi/aapr8yczOamVlPjRvXNtBEdDnQQC9p+qsA12zMzHqiMMhMmgSHHNLt1VS16a+CHGzMzPJ0Ogz5i1+E8eNbL7SWzwWrStNfhTnYmJklHQ5D/kh/WKeg5+Ghh2CffSpdzJrkYGNmlrQ3DHnfA/aEJfNbZ/ZTjrvFAwTMzJLC4cb9Vq1g5rmH84H8QDNzpgNND7hmY2aW5A9DbvPkTHCQWQuu2ZiZJacOG8J27y1pE2hu+/vzDjRryTUbM7NkxF4DGFGQdsvjs+t+pFgluGZjZjZlStvrZlauhAgHmhJxzcbMGlthkNloI1i6tDplqWMONmbWmG64AY4+unVaN/plGuEZNKXkYGNmjaewNnPYYXDbbV1evFGeQVNK7rMxs8bx4x8Xv3FmNwINNM4zaErJwcbMGoMEY8asmf75z3s8nLlRnkFTSm5GM7P6dsAB2YPN8q3lNTON8gyaUnLNxszql9Q60EyYUJKLMxvlGTSl5JqNmdWfwn4ZKOkdABrlGTSl5GBjZvVj5Uro16912pNPwoc+VPJNNcIzaErJwcbM6kOZazO2dtxnY2a1beHCtoFm/nwHml7GNRszqwlFr9jfa0DbjA4yvZJrNmbW6+Wu2J+zeBkBNM2Y3jbQvPeeA00v5pqNmfV6+Vfs+6FmtalsNRtJV0h6XdLTeWmbS7pL0ovp72YpXZIulDRD0lOS9spbZmTK/6KkkXnpH5U0LS1zoZQ12ra3DTOrXXMXL+Pzz97XJtDsOOo2B5oaUc5mtKuA4QVppwF3R8Rg4O40DXAoMDi9TgAuhixwAGcAHwf2Bs7ICx4Xp7y55YZ3sg0zq1Evn3s4F/5p7PvTU/rvzMBRt/mK/RpStmATEfcDCwuSjwTGpffj4P2H4h0JXB2Zh4FmSdsCw4C7ImJhRCwC7gKGp3mbRMRDERHA1QXrKrYNM6s1P/hBm5FmA0fdxn989Ze+Yr/GVLrP5gMRMQ8gIuZJ2jqltwCz8vLNTmkdpc8ukt7RNtqQdAJZ7Yjtt9++p/tkZuVQEGRmHTqCoz91CvIV+zWptwwQKHI1FtGD9G6JiEuASwCGDh3qhl+zHij5Q8T22gumTm2dFsF2wINrVVKrpkoPfX4tNYGR/r6e0mcD2+XlGwDM7SR9QJH0jrZhZiVWOCQ59xCxW6bO6dkKpdaB5sILPQCgTlQ62EwEciPKRgK35qUfm0al7QMsSU1hk4BDJG2WBgYcAkxK85ZK2ieNQju2YF3FtmFmJVayh4hJxR9qdsopa1lC6y3KOfT5j8BDwBBJsyUdD5wDfFbSi8Bn0zTAn4F/AjOAS4FvAUTEQuAs4LH0+nlKA/gv4LK0zEvAX1J6e9swsxJb64eIrVrVNsj87W+uzdShsvXZRMQx7cw6qEjeAE5qZz1XAFcUSZ8M7F4k/Y1i2zCz0lurh4j5xpkNxberMbMe69FDxBYvbhtoXn7ZgabO9ZbRaGZWg7r9EDHXZhqWg42ZrZUuPUTs+edhl11ap731Fmy4YfkKZr2Kg42ZlZdrM4b7bMysXCZObBtoVq92oGlQrtmY1aCSX7Vfaq7NWAHXbMxqTMmv2i+ls84qfnGmA03Dc7AxqzElu2q/1CT46U/XTA8b5iBj73MzmlmNWeur9ktt333h4YdbpznIWAHXbMxqTHtX51flQWJS60AzerQDjRXlmo1ZjTl12BBGT5jWqimtXA8Sa3cgggcAWDe5ZmNWY0bs2cKYo/agpbkJAS3NTYw5ao+Sj0YrOhDh5qfaBpqbb3agsU65ZmNWg7p01f5aKhyIMPPcw9tmcpCxLnLNxsyKyg042GD5sraB5umnHWisW1yzMbOi+jc38eDotk/r2H/M3Ty4225VKJHVMgcbM2vrlVfaBJoPfed6Vmy8KWPKMBDB6p+DjZm1VmSk2Y6jbuudt8WxmuFgY2aZBx6AT36yddqqVbDOOrxcnRJZHXGwMTNfN2Nl59FoZo3s0kt940yrCNdszBpVYZA56CD461+rUxare67ZmDWaE04oXptxoLEycrAxayRS1nSWc/rpbjKziuhSM5qkPhGxqvOcZtYrDRkCL7zQOs1BxiqoqzWbGZLGStq1rKUxs9KTWgea8eMdaKziujpA4EPA0cBlktYBrgCuj4g3y1YyM1s7Hs5svUiXajYRsTQiLo2I/YAfAWcA8ySNkzSorCU0s+5ZvrxtoHnySQcaq6ou99kAhwFfAwYCvwKuAz4J/Bn4YJnKZ2bd4dqM9VJdbUZ7EfgbMDYi/pGXPl7Sp0pfLDPrltdeg222aZ02fz5suWV1ymNWoNNgk2o1V0XEz4vNj4hvl7xUZnWg3Ucql5prM1YDOu2zSUOeD6hAWczqRtFHKk+Yxi1T55RuI1OmtA00y5c70Fiv1NVmtH9I+g1wA/B2LjEiHi9LqcxqXOEjlQGWrVjF2EnTS1O7cW3GakxXg81+6W9+U1oAB5a2OGb1IfdI5a6md9nvfw8nntg6zUHGakCXgk1EuBnNrBv6Nzcxp0hg6d/c1POVFtRmVmywIf3efqvn6zOroC7fG03SYZJ+JOmnuVc5C2ZWy04dNoSmfn1apTX168OpPXmk8qhRbQLNwFG38aHvjy9tH5BZGXX1OpvfARuQDRS4DPgC8GgZy2VW03L9Mms9Gq0gyFz50SP42cH/FyhxH5BZmXW5zyYiPiTpqYj4maRfARN6ulFJ3wO+QdbvM43sYtFtgeuBzYHHga9GxHJJ6wFXAx8F3gC+HBEz03pGA8cDq4BvR8SklD4c+B+gD3BZRJzT07Ka9dSIPVt6Hgg+8Ql48MFWSQNH3dYm21r3AZlVSFeb0XLf6Hck9QdWADv2ZIOSWoBvA0MjYneygHA0cC5wfkQMBhaRBRHS30URMQg4P+Uj3RT0aGA3YDhwkaQ+6bqg3wKHArsCx/gGolZTpNaB5qqr2H/M3UWzrlUfkFkFdTXY3CapGRhLVuuYSVYL6am+QJOkvmTNc/PIRraNT/PHASPS+yPTNGn+QZKU0q+PiPci4mVgBrB3es2IiH9GxPJUziPXoqxmlSEVf6jZyJGl7QMyq4Ku3ojzrIhYHBE3AzsAO0fE6T3ZYETMAX4JvEIWZJYAU4DFEbEyZZsN5NofWoBZadmVKf8W+ekFy7SX3oakEyRNljR5/vz5Pdkds7W3cmXbIPPQQ62GNI/Ys4UxR+1BS3MTAlqamxhz1B7ur7Ga0WGfjaSjOphHRHS730bSZmQ1jR2BxcBNZE1ehXL/aUWuXiM6SC8WQIteiBARlwCXAAwdOtQXK1jldePizLXqAzKrss4GCBzRwbygZ4MEDgZejoj5AJImkF002iypb6q9DADmpvyzge2A2anZbVNgYV56Tv4y7aWb9Q6LFsHmm7dOmz0bWhxMrD51GGwi4mtl2OYrwD6SNiAbeHAQMJnsrtJfIOtjGQncmvJPTNMPpfn3RERImgj8QdKvgf7AYLLh2AIGS9oRmEM2iOA/y7AfZj3jW81YA+rq0GckHUY28mv9XFp7d4LuSEQ8Imk82UCDlcBUsqas24HrJZ2d0i5Pi1wOXCNpBlmN5ui0nmck3Qg8m9ZzUrppKJJOBiaRjXS7IiKe6W45zUruuedg14KBkcuWwfrrF89vVkcUXfhF1d5FnRFxfIcL1pChQ4fG5MmTq10Mq1euzVidkjQlIoZ2lq+rQ5/3i4hjya53+RmwL637RcysmNtvbxtoVq92oLGG09VmtMKLOhfSw4s6zRpGYZBpackGAZg1oO5e1Hke2TUxL7N2F3Wa1a9LLy1+caYDjTWwzq6z+RgwKyLOStMbkd3L7HmyW8eYWb7CIDNqFJzjW/OZdVaz+T2wHEDSp4BzUtoS0sWQZgacfHLx2owDjRnQeZ9Nn4hYmN5/Gbgk3bLmZklPlLdoZjWiMMhcey185SvVKYtZL9VpsMm7qv8g4IRuLGtW3z76UXj88dZpHmVmVlRnAeOPwH2SFpCNSPs7gKRBZE1pZo0nAtYpaIF++GH4+MerUx6zGtDZ7Wr+W9LdZA82uzPWXAG6DnBKuQtn1uv44kyzHum0KSwiHi6S9kJ5imPWS739Nmy0Ueu0WbNgwIDqlMesxrjfxawzrs2YrbWuXtRp1nhmzmwbaJYudaAx6wHXbMyKcW3GrKRcszHLd++9bQPNqlUONGZryTUbs5zCILPuuvDee9Upi1mdcc3G7Le/LX6rGQcas5JxzcYaW2GQ+dznsmfQmFlJuWZjjem444rXZhxozMrCwcYajwTjxq2ZPvtsDwAwKzM3o1nj2GEHeOWV1mldDDK3TJ3D2EnTmbt4Gf2bmzh12BBG7NlShkKa1SfXbKz+RWS1mfxAM3FitwLN6AnTmLN4GQHMWbyM0ROmccvUOeUpr1kdcs3G6lsJLs4cO2k6y1asapW2bMUqxk6a7tqNWRe5ZmP16d132waaZ57pUd/M3MXLupVuZm25ZmP1p8S3munf3MScIoGlf3NTj9dp1mhcs7H6MW9e20DzxhtrPdLs1GFDaOrXp1VaU78+nDpsyFqt16yRuGZj9aGMN87M9ct4NJpZzznYWG179NG2j2NesQL6lvarPWLPFgcXs7XgYGMlU/FrUfwYALOa4T4bK4mKXoty//3FbzXjQGPWaznYWEl0dC1KSUnw6U+vmd5nHwcZsxrgYGMlUfZrUa68snht5qGHSrN+MysrBxsrifauOSnJtSgSfP3ra6avvtq1GbMa42BjJVGWa1FGjSpem/nqV3u+TjOrCo9Gs5Io+bUohUHm/vvhk59cy1KaWbU42FjJlORalEMOgbvuap3mJjOzmudgY73DqlVtL8R86SXYaafqlMfMSsrBxqpvk01g6dLWaa7NmNWVqgwQkNQsabyk5yU9J2lfSZtLukvSi+nvZimvJF0oaYakpyTtlbeekSn/i5JG5qV/VNK0tMyFUrFLza3qli7N+mbyA82iRQ40ZnWoWqPR/ge4IyJ2Bj4MPAecBtwdEYOBu9M0wKHA4PQ6AbgYQNLmwBnAx4G9gTNyASrlOSFvueEV2CfrDimr0eT06ZMFmebm6pXJzMqm4sFG0ibAp4DLASJieUQsBo4ExqVs44AR6f2RwNWReRholrQtMAy4KyIWRsQi4C5geJq3SUQ8FBEBXJ23Lqu2V15pO9Js+XJYubI65TGziqhGzWYnYD5wpaSpki6TtCHwgYiYB5D+bp3ytwCz8pafndI6Sp9dJL0NSSdImixp8vz589d+z6xjEuyww5rp/ffPajP9+lWvTGZWEdUINn2BvYCLI2JP4G3WNJkVU6y/JXqQ3jYx4pKIGBoRQ7faaquOS20998gjbWszq1fDAw8nJsJHAAAOuklEQVRUpzxmVnHVCDazgdkR8UiaHk8WfF5LTWCkv6/n5d8ub/kBwNxO0gcUSbdqkLKbZeacckpWm/GYDbOGUvFgExGvArMk5e5jchDwLDARyI0oGwncmt5PBI5No9L2AZakZrZJwCGSNksDAw4BJqV5SyXtk0ahHZu3LquUG28sfquZCy+sTnnMrKqqdZ3NKcB1ktYF/gl8jSzw3SjpeOAV4Isp75+BzwEzgHdSXiJioaSzgMdSvp9HxML0/r+Aq4Am4C/pZZVSGGQuvhhOPLFkq6/4Q9rMbK0pfE0DAEOHDo3JkydXuxi9VpdO8PfdB5/5TOu0En+/cg9py392TlO/Pow5ag8HHLMqkDQlIoZ2ls93fbZOdekpnFLrQHPnnWW5OLNiD2kzs5JysLFOdXiCv+mm1s1me+6ZBZnPfrYsZZnTzsPY2ks3s97B90azThV92mYED44+qHXa669DmYeQ95FYVaTG1Mej28x6NddsrFOFT9v8+mO3MvO8I9YkfOlLWW2mAtcqFQs0HaWbWe/gmo116tRhQxg9YRor3n2PGb8suPPPW2/BhhsClRkl1tLcVLTJrKUUj582s7JxzcY6NWLPFv708oRWgeaF476V1WbyAk2ngwhKoCyPnzazsnPNxjr21luw8cYMyk9bsYIPFjzorKNBBKWs3ZT88dNmVhEONta+ESPg1rybL/zmN3DSSUWzFh1E0EH6WhWrFI+fNrOKcrCxtl57DbbZpnXa6tUd3s+sfzt9KYWDC8ysMbnPxlrbbbfWgWbChC7dONN9KWbWEddsLPPCCzCkIDB0Yzix+1LMrCMONgbrrNM6sDzwQPZgs25yX4qZtcfBppE9/DDsu2/rNF8caWZl4GDTqAr7YJ57DnbeuTplMbO65wECjWbixNaB5oMfzGozDjRmVkau2TSKiKxvJt/cubDtttUpj5k1FNdsGsHvftc60Bx2WBZ8HGjMrEJcs6lnq1ZBwW1lePNN2Hjj6pTHzBqWazb16ic/aR1oTjklq8040JhZFbhmU2/eeef9OzG/b/ly6NevOuUxM8M1m/py882tA83YsVltxoHGzKrMNZt68M47sPnm8N57a9I6uXGmmVkluWZT6y69NKvN5ALNtGldunGmmVkluWZTqxYtymozOccdB1deWbXimJl1xDWbWjRmTOtA8/LLDjRm1qu5ZlNL5s6Flry7Ko8aBeecU73ymJl1kYNNrfje9+CCC9ZMv/oqfOAD1SuPmVk3uBmtt5sxI+vszwWaX/4yGwDgQGNmNcQ1m97smGPg+uvXTC9eDJtuWr3ymJn1kGs2vdETT2S1mVygufLKrDbjQGNmNco1m94kAg48EO69N5tuboZ582D99ataLDOzteWaTW9x//3ZYwBygebWW7NraRxozKwOuGZTbStXwu67w/Tp2fTOO2d3ASh8NICZWQ1zzaaaJk7MbpKZCzT33QfPPedAY2Z1x2e1anj3XdhmG1iyJJs+4AC4+27fz8zM6pZrNpU2bhw0Na0JNFOnwj33ONCYWV2rWrCR1EfSVEm3pekdJT0i6UVJN0haN6Wvl6ZnpPkD89YxOqVPlzQsL314Spsh6bRK71tRS5ZkAeW447LpY47JRp995CNVLZaZWSVUs2bzHeC5vOlzgfMjYjCwCDg+pR8PLIqIQcD5KR+SdgWOBnYDhgMXpQDWB/gtcCiwK3BMyls9v/pVNow558UX4Q9/KPlmbpk6h/3PuYcdT7ud/c+5h1umzin5NszMeqIqwUbSAOAw4LI0LeBAYHzKMg4Ykd4fmaZJ8w9K+Y8Ero+I9yLiZWAGsHd6zYiIf0bEcuD6lLfkOj25v/ZaVpv54Q+z6e9+N6vNDBpUlrKMnjCNOYuXEcCcxcsYPWGaA46Z9QrVqtlcAPwIWJ2mtwAWR8TKND0byN3euAWYBZDmL0n5308vWKa99DYknSBpsqTJ8+fP79YOdHpyHzUqGwSQM3cunH9+t7bRHWMnTWfZilWt0patWMXYSdPLtk0zs66qeLCRdDjwekRMyU8ukjU6mdfd9LaJEZdExNCIGLrVVlt1UOq22ju5X3P9fVlt5rzzssRf/CKrzWy7bbfW311zFy/rVrqZWSVVY+jz/sDnJX0OWB/YhKym0yypb6q9DADmpvyzge2A2ZL6ApsCC/PSc/KXaS+9ZIqdxMfefgFffPqvaxIWLoTNNiv1povq39zEnCJl6t/cVJHtm5l1pOI1m4gYHREDImIgWQf/PRHxFeBvwBdStpHAren9xDRNmn9PRERKPzqNVtsRGAw8CjwGDE6j29ZN25hY6v3IP4kPmT+TmecevibQXHJJVpupUKABOHXYEJr69WmV1tSvD6cOG1KxMpiZtac3XWczCvi+pBlkfTKXp/TLgS1S+veB0wAi4hngRuBZ4A7gpIhYlWpGJwOTyEa73ZjyllTu5L7VWwuZdMXJALzbd13+9OCL8M1vlnpznRqxZwtjjtqDluYmBLQ0NzHmqD0YsWfR7iozs4pSVkmwoUOHxuTJk7u1zC1T5/DbWx/nJ1f/jLv2O5yP/eCbPrmbWUORNCUihnaaz8Em05NgY2bW6LoabHpTM5qZmdUpBxszMys7BxszMys7BxszMys7BxszMys7BxszMys7BxszMys7BxszMys7X9SZSJoP/Kva5eimLYEF1S5EFTX6/oOPQaPvP1T/GOwQEZ3eNt/BpoZJmtyVK3frVaPvP/gYNPr+Q+0cAzejmZlZ2TnYmJlZ2TnY1LZLql2AKmv0/Qcfg0bff6iRY+A+GzMzKzvXbMzMrOwcbMzMrOwcbGqMpO0k/U3Sc5KekfSdapepGiT1kTRV0m3VLks1SGqWNF7S8+m7sG+1y1Rpkr6X/geelvRHSetXu0zlJukKSa9LejovbXNJd0l6Mf3drJplbI+DTe1ZCfwgInYB9gFOkrRrlctUDd8Bnqt2Iarof4A7ImJn4MM02LGQ1AJ8GxgaEbsDfYCjq1uqirgKGF6Qdhpwd0QMBu5O072Og02NiYh5EfF4er+U7CTTUt1SVZakAcBhwGXVLks1SNoE+BRwOUBELI+IxdUtVVX0BZok9QU2AOZWuTxlFxH3AwsLko8ExqX344ARFS1UFznY1DBJA4E9gUeqW5KKuwD4EbC62gWpkp2A+cCVqSnxMkkbVrtQlRQRc4BfAq8A84AlEXFndUtVNR+IiHmQ/RgFtq5yeYpysKlRkjYCbga+GxFvVrs8lSLpcOD1iJhS7bJUUV9gL+DiiNgTeJte2nRSLqlf4khgR6A/sKGk/1PdUllHHGxqkKR+ZIHmuoiYUO3yVNj+wOclzQSuBw6UdG11i1Rxs4HZEZGr0Y4nCz6N5GDg5YiYHxErgAnAflUuU7W8JmlbgPT39SqXpygHmxojSWRt9c9FxK+rXZ5Ki4jRETEgIgaSdQjfExEN9Ys2Il4FZkkakpIOAp6tYpGq4RVgH0kbpP+Jg2iwQRJ5JgIj0/uRwK1VLEu7+la7ANZt+wNfBaZJeiKl/Tgi/lzFMlnlnQJcJ2ld4J/A16pcnoqKiEckjQceJxuhOZUauW3L2pD0R+AzwJaSZgNnAOcAN0o6niwIf7F6JWyfb1djZmZl52Y0MzMrOwcbMzMrOwcbMzMrOwcbMzMrOwcbMzMrOwcbq2vKPCDp0Ly0L0m6o8plulHSU5K+Xa1ypLL0kfT3apbBGoOHPlvdk7Q7cBPZfeT6AE8AwyPipbVYZ9+IWNnDZQcA90XEv/V0+6WwNvtg1l2u2Vjdi4ingT8Bo8gugrs6Il6SNFLSo5KekHSRpHUAJF0iaXJ6VspPc+uRNFvS6ZIeBP49PU/lWUlPFrtljqQmSeMkTZP0uKRPpVl3Av3TdvcrWOYDkiak7T8qaZ+UfpGkH6f3h6VnGknStZIulvR3SS/kanCS+kr6dVrHU5K+kdIPlvRXSdcDU1O+xXnbPy1vmZ+mtEHpmTGXp2Pyl9yzYyR9UNI96Rg8nm4OW3Q91uAiwi+/6v4FbAhMB6YB6wG7A7cAfdP8S4D/TO83T3/7An8Hdk3Ts4Hv561zHrBuet9cZJujgEvT+92AfwHrAoOAJ9op5w3APun9QODpvPI/S3b1+AvAjin9WuA2sh+OQ4BZaf++BZyW8qxHdoX99mT3FHsL2D5vHxen958DLgKU1ncH2f3GBgErgD1SvgnA0en9FOCI9H59slv9F11Ptb8DflX35dvVWEOIiLcl3QC8FRHvSToY+BgwObu1Fk1kJ2qAY9KtP/qS3VF4V9bce+yGvNU+A1wr6VaywFXoE8DYtP1nJM0lO3Ev76CoBwNDUpkANpPUlMp/InAPcEpEvJy3zI0RsRqYLmkWMBg4BNhFUu6BYpumdICHIuKVIts+BDiULDABbAR8kOzGjjMiYlpKnwIMTHde3jIi/pT28V0ASe2t5x8d7LfVOQcbaySrWfMMHAFXRMTp+RkkDSZ7CujeEbE4NY/lP2747bz3w4BPk93q/v+TtHtErMpfXQ/KqLTtYgFpD+ANsgCYr7DjNdJ6vhURd7daeRZk36Y4AWdHxOUFywwC3stLWsWac0exTt+i67HG5j4ba1R/Bb4kaUsASVtI2h7YBFgKvJlu1z6s2MKS+gADIuIe4FRgK7ImpHz3A19J+XcBtgVmdKFcJ+Vt5yPp705kj0H+CHCkpKF5y3wx9d98ENgOeBGYBHxL2VMskTREUlMn254EHK/0IDZJA3LHp5iIWAQskHREyr++pA26ux5rDK7ZWEOKiGmSfgb8NQ0MWAGcCEwmazJ7muxuyg+2s4q+wB8kbUz2o+3cyB7Tne//Ab+XNC2t/9iIWJ7XRFbMScDFkr6WtvE3SScDVwDfi4h5qbP/ckl7p2VmkAW2rYET0jZ+T9ZH80Ta3utkNbCOjsmfJe0MPJyWWQr8Z0fLkAXT30v6b7Lmwf/oYD0LOlmX1TEPfTarYamZb3xEFOszMus13IxmZmZl55qNmZmVnWs2ZmZWdg42ZmZWdg42ZmZWdg42ZmZWdg42ZmZWdv8/cckYXVuAiEkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#let's see how train set is predicted using gradient descent\n",
    "plt.scatter(X_train,Y_train)\n",
    "plt.plot(X_train,y_pred_train,'r')\n",
    "plt.xlabel('Years of experience')\n",
    "plt.ylabel('Salary')\n",
    "plt.title('Training set prediction using Gradient Descent')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#let's see how train set is predicted using normal equation\n",
    "plt.scatter(X_train,Y_train)\n",
    "plt.plot(X_train,y_pred_train_normal,'r')\n",
    "plt.xlabel('X_axis')\n",
    "plt.ylabel('Y_axis')\n",
    "plt.title('Training set prediction using Normal Equation')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#let's see how test set is predicted using gradient descent\n",
    "plt.scatter(X_test,Y_test)\n",
    "plt.plot(X_test,y_pred_grad,'r')\n",
    "plt.xlabel('X_axis')\n",
    "plt.ylabel('Y_axis')\n",
    "plt.title('Test set prediction using Gradient Descent')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#let's see how test set is predicted using normal equation method\n",
    "plt.scatter(X_test,Y_test)\n",
    "plt.plot(X_test,y_pred_normal,'r')\n",
    "plt.xlabel('X_axis')\n",
    "plt.ylabel('Y_axis')\n",
    "plt.title('Test set prediction using Normal Equation')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot of how cost function is minimized as number of iterations is proceeded\n",
    "x=[i for i in range(1000)]\n",
    "plt.plot(x,J_Array)\n",
    "plt.xlabel('Number of iterations')\n",
    "plt.ylabel('Cost function(J)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
